home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / mac / raytrace / dkb / mcprt102.bnh / DKBTrace-Mac / raw.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-09  |  11.2 KB  |  365 lines
  1. /*****************************************************************************
  2. *
  3. *                                     raw.c
  4. *
  5. *   from DKBTrace (c) 1990  David Buck
  6. *
  7. *  This module contains the code to read and write the default file format
  8. *  generated by DKBTrace.  The format is as follows:
  9. *
  10. *
  11. *  (header:)
  12. *    wwww hhhh       - Width, Height (16 bits, LSB first)
  13. *
  14. *  (each scanline:)
  15. *    llll            - Line number (16 bits, LSB first)
  16. *    rr rr rr ...    - Red data for line (8 bits per pixel,
  17. *                       left to right, 0-255 (255=bright, 0=dark))
  18. *    gg gg gg ...    - Green data for line (8 bits per pixel,
  19. *                       left to right, 0-255 (255=bright, 0=dark))
  20. *    bb bb bb ...    - Blue data for line (8 bits per pixel,
  21. *                       left to right, 0-255 (255=bright, 0=dark))
  22. *
  23. * This software is freely distributable. The source and/or object code may be
  24. * copied or uploaded to communications services so long as this notice remains
  25. * at the top of each file.  If any changes are made to the program, you must
  26. * clearly indicate in the documentation and in the programs startup message
  27. * who it was who made the changes. The documentation should also describe what
  28. * those changes were. This software may not be included in whole or in
  29. * part into any commercial package without the express written consent of the
  30. * author.  It may, however, be included in other public domain or freely
  31. * distributed software so long as the proper credit for the software is given.
  32. *
  33. * This software is provided as is without any guarantees or warranty. Although
  34. * the author has attempted to find and correct any bugs in the software, he
  35. * is not responsible for any damage caused by the use of the software.  The
  36. * author is under no obligation to provide service, corrections, or upgrades
  37. * to this package.
  38. *
  39. * Despite all the legal stuff above, if you do find bugs, I would like to hear
  40. * about them.  Also, if you have any comments or questions, you may contact me
  41. * at the following address:
  42. *
  43. *     David Buck
  44. *     22C Sonnet Cres.
  45. *     Nepean Ontario
  46. *     Canada, K2H 8W7
  47. *
  48. *  I can also be reached on the following bulleton boards:
  49. *
  50. *     OMX              (613) 731-3419
  51. *     Mystic           (613) 596-4249  or  (613) 596-4772
  52. *
  53. *  Fidonet:   1:163/109.9
  54. *  Internet:  dbuck@ccs.carleton.ca
  55. *  The "You Can Call Me RAY" BBS    (708) 358-5611
  56. *
  57. *  IBM Port by Aaron A. Collins. Aaron may be reached on the following BBS'es:
  58. *
  59. *     The "You Can Call Me RAY" BBS (708) 358-5611
  60. *     The Information Exchange BBS  (708) 945-5575
  61. *
  62. *****************************************************************************/
  63.  
  64. #include "frame.h"
  65. #include "dkbproto.h"
  66.  
  67. struct Raw_File_Handle_Struct {
  68.    FILE_HANDLE root;
  69.    FILE *Red_File, *Green_File, *Blue_File;
  70.    char *Red_Buffer, *Green_Buffer, *Blue_Buffer;
  71.    int line_number;
  72.    };
  73.  
  74. typedef struct Raw_File_Handle_Struct RAW_FILE_HANDLE;
  75.  
  76. FILE_HANDLE *Get_Raw_File_Handle()
  77.    {
  78.    RAW_FILE_HANDLE *handle;
  79.  
  80.    if ((handle = (RAW_FILE_HANDLE *) malloc(sizeof(RAW_FILE_HANDLE))) == NULL) {
  81.       fprintf (stderr, "Cannot allocate memory for output file handle\n");
  82.       return(NULL);
  83.       }
  84.  
  85.    handle->root.Default_File_Name_p = Default_Raw_File_Name;
  86.    handle->root.Open_File_p = Open_Raw_File;
  87.    handle->root.Write_Line_p = Write_Raw_Line;
  88.    handle->root.Read_Line_p = Read_Raw_Line;
  89.    handle->root.Close_File_p = Close_Raw_File;
  90.    return ((FILE_HANDLE *) handle);
  91.    }
  92.  
  93. char *Default_Raw_File_Name()
  94.    {
  95.    return ("data");
  96.    }
  97.  
  98. int Open_Raw_File (handle, name, width, height, buffer_size, mode)
  99.    FILE_HANDLE *handle;
  100.    char *name;
  101.    int *width;
  102.    int *height;
  103.    int buffer_size;
  104.    int mode;
  105.    {
  106.    RAW_FILE_HANDLE *raw_handle;
  107.    char file_name[256];
  108.  
  109.    handle->mode = mode;
  110.    handle->filename = name;
  111.    raw_handle = (RAW_FILE_HANDLE *) handle;
  112.    raw_handle->line_number = 0;
  113.  
  114.    switch (mode) {
  115.       case READ_MODE:
  116.          strcpy (file_name, name);
  117.          strcat (file_name, RED_RAW_FILE_EXTENSION);
  118.  
  119.          if ((raw_handle->Red_File = fopen (file_name, "rb")) == NULL)
  120.             return(0);
  121.  
  122.          strcpy (file_name, name);
  123.          strcat (file_name, GREEN_RAW_FILE_EXTENSION);
  124.  
  125.          if ((raw_handle->Green_File = fopen (file_name, "rb")) == NULL)
  126.             return(0);
  127.  
  128.          strcpy (file_name, name);
  129.          strcat (file_name, BLUE_RAW_FILE_EXTENSION);
  130.  
  131.          if ((raw_handle->Blue_File = fopen (file_name, "rb")) == NULL)
  132.             return(0);
  133.  
  134.          if (buffer_size != 0) {
  135.             if ((raw_handle->Red_Buffer = malloc (buffer_size)) == NULL)
  136.                return(0);
  137.  
  138.             setvbuf (raw_handle->Red_File, raw_handle->Red_Buffer, _IOFBF, buffer_size);
  139.             }
  140.  
  141.          if (buffer_size != 0) {
  142.             if ((raw_handle->Green_Buffer = malloc (buffer_size)) == NULL)
  143.                return(0);
  144.  
  145.             setvbuf (raw_handle->Green_File, raw_handle->Green_Buffer, _IOFBF, buffer_size);
  146.             }
  147.  
  148.          if (buffer_size != 0) {
  149.             if ((raw_handle->Blue_Buffer = malloc (buffer_size)) == NULL)
  150.                return(0);
  151.  
  152.             setvbuf (raw_handle->Blue_File, raw_handle->Blue_Buffer, _IOFBF, buffer_size);
  153.             }
  154.  
  155.          handle->width = *width;
  156.          handle->height = *height;
  157.          handle->buffer_size = buffer_size;
  158.          break;
  159.  
  160.       case WRITE_MODE:
  161.          strcpy (file_name, name);
  162.          strcat (file_name, RED_RAW_FILE_EXTENSION);
  163.  
  164.          if ((raw_handle->Red_File = fopen (file_name, "wb")) == NULL)
  165.             return(0);
  166.  
  167.          if (buffer_size != 0) {
  168.             if ((raw_handle->Red_Buffer = malloc (buffer_size)) == NULL)
  169.                return(0);
  170.  
  171.             setvbuf (raw_handle->Red_File, raw_handle->Red_Buffer, _IOFBF, buffer_size);
  172.             }
  173.  
  174. #ifdef Macintosh
  175.          SetTypeAndCreator(file_name, Raw_Type, Raw_Creator);
  176. #endif
  177.  
  178.          strcpy (file_name, name);
  179.          strcat (file_name, GREEN_RAW_FILE_EXTENSION);
  180.  
  181.          if ((raw_handle->Green_File = fopen (file_name, "wb")) == NULL)
  182.             return(0);
  183.  
  184.          if (buffer_size != 0) {
  185.             if ((raw_handle->Green_Buffer = malloc (buffer_size)) == NULL)
  186.                return(0);
  187.  
  188.             setvbuf (raw_handle->Green_File, raw_handle->Green_Buffer, _IOFBF, buffer_size);
  189.             }
  190.  
  191. #ifdef Macintosh
  192.          SetTypeAndCreator(file_name, Raw_Type, Raw_Creator);
  193. #endif
  194.  
  195.          strcpy (file_name, name);
  196.          strcat (file_name, BLUE_RAW_FILE_EXTENSION);
  197.  
  198.          if ((raw_handle->Blue_File = fopen (file_name, "wb")) == NULL)
  199.             return(0);
  200.  
  201.          if (buffer_size != 0) {
  202.             if ((raw_handle->Blue_Buffer = malloc (buffer_size)) == NULL)
  203.                return(0);
  204.  
  205.             setvbuf (raw_handle->Blue_File, raw_handle->Blue_Buffer, _IOFBF, buffer_size);
  206.             }
  207.  
  208. #ifdef Macintosh
  209.          SetTypeAndCreator(file_name, Raw_Type, Raw_Creator);
  210. #endif
  211.  
  212.          handle->width = *width;
  213.          handle->height = *height;
  214.          handle->buffer_size = buffer_size;
  215.  
  216.          break;
  217.  
  218.       case APPEND_MODE:
  219.          strcpy (file_name, name);
  220.          strcat (file_name, RED_RAW_FILE_EXTENSION);
  221.  
  222.          if ((raw_handle->Red_File = fopen (file_name, "ab")) == NULL)
  223.             return(0);
  224.  
  225.          if (buffer_size != 0) {
  226.             if ((raw_handle->Red_Buffer = malloc (buffer_size)) == NULL)
  227.                return(0);
  228.  
  229.             setvbuf (raw_handle->Red_File, raw_handle->Red_Buffer, _IOFBF, buffer_size);
  230.             }
  231.  
  232.          strcpy (file_name, name);
  233.          strcat (file_name, GREEN_RAW_FILE_EXTENSION);
  234.  
  235.          if ((raw_handle->Green_File = fopen (file_name, "ab")) == NULL)
  236.             return(0);
  237.  
  238.          if (buffer_size != 0) {
  239.             if ((raw_handle->Green_Buffer = malloc (buffer_size)) == NULL)
  240.                return(0);
  241.  
  242.             setvbuf (raw_handle->Green_File, raw_handle->Green_Buffer, _IOFBF, buffer_size);
  243.             }
  244.  
  245.          strcpy (file_name, name);
  246.          strcat (file_name, BLUE_RAW_FILE_EXTENSION);
  247.  
  248.          if ((raw_handle->Blue_File = fopen (file_name, "ab")) == NULL)
  249.             return(0);
  250.  
  251.          if (buffer_size != 0) {
  252.             if ((raw_handle->Blue_Buffer = malloc (buffer_size)) == NULL)
  253.                return(0);
  254.  
  255.             setvbuf (raw_handle->Blue_File, raw_handle->Blue_Buffer, _IOFBF, buffer_size);
  256.             }
  257.  
  258.          handle->width = *width;
  259.          handle->height = *height;
  260.          handle->buffer_size = buffer_size;
  261.  
  262.          break;
  263.       }
  264.    return(1);
  265.    }
  266.  
  267. void Write_Raw_Line (handle, line_data, line_number)
  268.    FILE_HANDLE *handle;
  269.    COLOUR *line_data;
  270.    int line_number;
  271.    {
  272.    register int x;
  273.    RAW_FILE_HANDLE *raw_handle;
  274.    char file_name[256];
  275.  
  276.    raw_handle = (RAW_FILE_HANDLE *) handle;
  277.  
  278.    for (x = 0 ; x < handle->width ; x++)
  279.       putc((int) floor (line_data[x].Red * 255.0), raw_handle->Red_File);
  280.  
  281.    for (x = 0 ; x < handle->width ; x++)
  282.       putc((int) floor (line_data[x].Green * 255.0), raw_handle->Green_File);
  283.  
  284.    for (x = 0 ; x < handle->width ; x++)
  285.       putc((int) floor (line_data[x].Blue * 255.0), raw_handle->Blue_File);
  286.  
  287.    if (handle->buffer_size == 0) {
  288.       fflush(raw_handle->Red_File);                       /* close and reopen file for */
  289.       strcpy (file_name, handle->filename);
  290.       strcat (file_name, RED_RAW_FILE_EXTENSION);
  291.       raw_handle->Red_File = freopen(file_name, "ab",
  292.                     raw_handle->Red_File);                /* integrity in case we crash*/
  293.  
  294.       fflush(raw_handle->Green_File);                       /* close and reopen file for */
  295.       strcpy (file_name, handle->filename);
  296.       strcat (file_name, GREEN_RAW_FILE_EXTENSION);
  297.       raw_handle->Green_File = freopen(file_name, "ab",
  298.                     raw_handle->Green_File);                /* integrity in case we crash*/
  299.  
  300.       fflush(raw_handle->Blue_File);                       /* close and reopen file for */
  301.       strcpy (file_name, handle->filename);
  302.       strcat (file_name, BLUE_RAW_FILE_EXTENSION);
  303.       raw_handle->Blue_File = freopen(file_name, "ab",
  304.                     raw_handle->Blue_File);                /* integrity in case we crash*/
  305.       }
  306.    }
  307.  
  308. int Read_Raw_Line (handle, line_data, line_number)
  309.    FILE_HANDLE *handle;
  310.    COLOUR *line_data;
  311.    int *line_number;
  312.    {
  313.    int data, i;
  314.    RAW_FILE_HANDLE *raw_handle;
  315.    
  316.    raw_handle = (RAW_FILE_HANDLE *) handle;
  317.  
  318.    for (i = 0 ; i < handle->width ; i++) {
  319.       if ((data = getc(raw_handle->Red_File)) == EOF) {
  320.          if (i == 0)
  321.             return(0);
  322.          else
  323.             return(-1);
  324.          }
  325.  
  326.       line_data[i].Red = (DBL) data / 255.0;
  327.       }
  328.  
  329.    for (i = 0 ; i < handle->width ; i++) {
  330.       if ((data = getc(raw_handle->Green_File)) == EOF)
  331.          return(-1);
  332.  
  333.       line_data[i].Green = (DBL) data / 255.0;
  334.       }
  335.  
  336.    for (i = 0 ; i < handle->width ; i++) {
  337.       if ((data = getc(raw_handle->Blue_File)) == EOF)
  338.          return(-1);
  339.  
  340.       line_data[i].Blue = (DBL) data / 255.0;
  341.       }
  342.  
  343.    *line_number = raw_handle->line_number++;
  344.    return (1);
  345.    }
  346.  
  347. void Close_Raw_File (handle)
  348.    FILE_HANDLE *handle;
  349.    {
  350.    RAW_FILE_HANDLE *raw_handle;
  351.  
  352.    raw_handle = (RAW_FILE_HANDLE *) handle;
  353.  
  354.    fclose (raw_handle->Red_File);
  355.    fclose (raw_handle->Green_File);
  356.    fclose (raw_handle->Blue_File);
  357.  
  358.    if (handle->buffer_size != 0) {
  359.       free (raw_handle->Red_Buffer);
  360.       free (raw_handle->Green_Buffer);
  361.       free (raw_handle->Blue_Buffer);
  362.       }
  363.    }
  364.  
  365.